home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / sound / core.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  14.2 KB  |  449 lines
  1. #ifndef __SOUND_CORE_H
  2. #define __SOUND_CORE_H
  3.  
  4. /*
  5.  *  Main header file for the ALSA driver
  6.  *  Copyright (c) 1994-2001 by Jaroslav Kysela <perex@perex.cz>
  7.  *
  8.  *
  9.  *   This program is free software; you can redistribute it and/or modify
  10.  *   it under the terms of the GNU General Public License as published by
  11.  *   the Free Software Foundation; either version 2 of the License, or
  12.  *   (at your option) any later version.
  13.  *
  14.  *   This program is distributed in the hope that it will be useful,
  15.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  *   GNU General Public License for more details.
  18.  *
  19.  *   You should have received a copy of the GNU General Public License
  20.  *   along with this program; if not, write to the Free Software
  21.  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  22.  *
  23.  */
  24.  
  25. #include <linux/module.h>
  26. #include <linux/sched.h>        /* wake_up() */
  27. #include <linux/mutex.h>        /* struct mutex */
  28. #include <linux/rwsem.h>        /* struct rw_semaphore */
  29. #include <linux/pm.h>            /* pm_message_t */
  30. #include <linux/device.h>
  31. #include <linux/stringify.h>
  32.  
  33. /* number of supported soundcards */
  34. #ifdef CONFIG_SND_DYNAMIC_MINORS
  35. #define SNDRV_CARDS 32
  36. #else
  37. #define SNDRV_CARDS 8        /* don't change - minor numbers */
  38. #endif
  39.  
  40. #define CONFIG_SND_MAJOR    116    /* standard configuration */
  41.  
  42. /* forward declarations */
  43. #ifdef CONFIG_PCI
  44. struct pci_dev;
  45. #endif
  46.  
  47. /* device allocation stuff */
  48.  
  49. #define SNDRV_DEV_TYPE_RANGE_SIZE        0x1000
  50.  
  51. typedef int __bitwise snd_device_type_t;
  52. #define    SNDRV_DEV_TOPLEVEL    ((__force snd_device_type_t) 0)
  53. #define    SNDRV_DEV_CONTROL    ((__force snd_device_type_t) 1)
  54. #define    SNDRV_DEV_LOWLEVEL_PRE    ((__force snd_device_type_t) 2)
  55. #define    SNDRV_DEV_LOWLEVEL_NORMAL ((__force snd_device_type_t) 0x1000)
  56. #define    SNDRV_DEV_PCM        ((__force snd_device_type_t) 0x1001)
  57. #define    SNDRV_DEV_RAWMIDI    ((__force snd_device_type_t) 0x1002)
  58. #define    SNDRV_DEV_TIMER        ((__force snd_device_type_t) 0x1003)
  59. #define    SNDRV_DEV_SEQUENCER    ((__force snd_device_type_t) 0x1004)
  60. #define    SNDRV_DEV_HWDEP        ((__force snd_device_type_t) 0x1005)
  61. #define    SNDRV_DEV_INFO        ((__force snd_device_type_t) 0x1006)
  62. #define    SNDRV_DEV_BUS        ((__force snd_device_type_t) 0x1007)
  63. #define    SNDRV_DEV_CODEC        ((__force snd_device_type_t) 0x1008)
  64. #define    SNDRV_DEV_JACK          ((__force snd_device_type_t) 0x1009)
  65. #define    SNDRV_DEV_LOWLEVEL    ((__force snd_device_type_t) 0x2000)
  66.  
  67. typedef int __bitwise snd_device_state_t;
  68. #define    SNDRV_DEV_BUILD        ((__force snd_device_state_t) 0)
  69. #define    SNDRV_DEV_REGISTERED    ((__force snd_device_state_t) 1)
  70. #define    SNDRV_DEV_DISCONNECTED    ((__force snd_device_state_t) 2)
  71.  
  72. typedef int __bitwise snd_device_cmd_t;
  73. #define    SNDRV_DEV_CMD_PRE    ((__force snd_device_cmd_t) 0)
  74. #define    SNDRV_DEV_CMD_NORMAL    ((__force snd_device_cmd_t) 1)    
  75. #define    SNDRV_DEV_CMD_POST    ((__force snd_device_cmd_t) 2)
  76.  
  77. struct snd_device;
  78.  
  79. struct snd_device_ops {
  80.     int (*dev_free)(struct snd_device *dev);
  81.     int (*dev_register)(struct snd_device *dev);
  82.     int (*dev_disconnect)(struct snd_device *dev);
  83. };
  84.  
  85. struct snd_device {
  86.     struct list_head list;        /* list of registered devices */
  87.     struct snd_card *card;        /* card which holds this device */
  88.     snd_device_state_t state;    /* state of the device */
  89.     snd_device_type_t type;        /* device type */
  90.     void *device_data;        /* device structure */
  91.     struct snd_device_ops *ops;    /* operations */
  92. };
  93.  
  94. #define snd_device(n) list_entry(n, struct snd_device, list)
  95.  
  96. /* monitor files for graceful shutdown (hotplug) */
  97.  
  98. struct snd_monitor_file {
  99.     struct file *file;
  100.     struct snd_monitor_file *next;
  101.     const struct file_operations *disconnected_f_op;
  102.     struct list_head shutdown_list;
  103. };
  104.  
  105. /* main structure for soundcard */
  106.  
  107. struct snd_card {
  108.     int number;            /* number of soundcard (index to
  109.                                 snd_cards) */
  110.  
  111.     char id[16];            /* id string of this card */
  112.     char driver[16];        /* driver name */
  113.     char shortname[32];        /* short name of this soundcard */
  114.     char longname[80];        /* name of this soundcard */
  115.     char mixername[80];        /* mixer name */
  116.     char components[128];        /* card components delimited with
  117.                                 space */
  118.     struct module *module;        /* top-level module */
  119.  
  120.     void *private_data;        /* private data for soundcard */
  121.     void (*private_free) (struct snd_card *card); /* callback for freeing of
  122.                                 private data */
  123.     struct list_head devices;    /* devices */
  124.  
  125.     unsigned int last_numid;    /* last used numeric ID */
  126.     struct rw_semaphore controls_rwsem;    /* controls list lock */
  127.     rwlock_t ctl_files_rwlock;    /* ctl_files list lock */
  128.     int controls_count;        /* count of all controls */
  129.     int user_ctl_count;        /* count of all user controls */
  130.     struct list_head controls;    /* all controls for this card */
  131.     struct list_head ctl_files;    /* active control files */
  132.  
  133.     struct snd_info_entry *proc_root;    /* root for soundcard specific files */
  134.     struct snd_info_entry *proc_id;    /* the card id */
  135.     struct proc_dir_entry *proc_root_link;    /* number link to real id */
  136.  
  137.     struct snd_monitor_file *files; /* all files associated to this card */
  138.     struct snd_shutdown_f_ops *s_f_ops; /* file operations in the shutdown
  139.                                 state */
  140.     spinlock_t files_lock;        /* lock the files for this card */
  141.     int shutdown;            /* this card is going down */
  142.     int free_on_last_close;        /* free in context of file_release */
  143.     wait_queue_head_t shutdown_sleep;
  144.     struct device *dev;        /* device assigned to this card */
  145. #ifndef CONFIG_SYSFS_DEPRECATED
  146.     struct device *card_dev;    /* cardX object for sysfs */
  147. #endif
  148.  
  149. #ifdef CONFIG_PM
  150.     unsigned int power_state;    /* power state */
  151.     struct mutex power_lock;    /* power lock */
  152.     wait_queue_head_t power_sleep;
  153. #endif
  154.  
  155. #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
  156.     struct snd_mixer_oss *mixer_oss;
  157.     int mixer_oss_change_count;
  158. #endif
  159. };
  160.  
  161. #ifdef CONFIG_PM
  162. static inline void snd_power_lock(struct snd_card *card)
  163. {
  164.     mutex_lock(&card->power_lock);
  165. }
  166.  
  167. static inline void snd_power_unlock(struct snd_card *card)
  168. {
  169.     mutex_unlock(&card->power_lock);
  170. }
  171.  
  172. static inline unsigned int snd_power_get_state(struct snd_card *card)
  173. {
  174.     return card->power_state;
  175. }
  176.  
  177. static inline void snd_power_change_state(struct snd_card *card, unsigned int state)
  178. {
  179.     card->power_state = state;
  180.     wake_up(&card->power_sleep);
  181. }
  182.  
  183. /* init.c */
  184. int snd_power_wait(struct snd_card *card, unsigned int power_state);
  185.  
  186. #else /* ! CONFIG_PM */
  187.  
  188. #define snd_power_lock(card)        do { (void)(card); } while (0)
  189. #define snd_power_unlock(card)        do { (void)(card); } while (0)
  190. static inline int snd_power_wait(struct snd_card *card, unsigned int state) { return 0; }
  191. #define snd_power_get_state(card)    SNDRV_CTL_POWER_D0
  192. #define snd_power_change_state(card, state)    do { (void)(card); } while (0)
  193.  
  194. #endif /* CONFIG_PM */
  195.  
  196. struct snd_minor {
  197.     int type;            /* SNDRV_DEVICE_TYPE_XXX */
  198.     int card;            /* card number */
  199.     int device;            /* device number */
  200.     const struct file_operations *f_ops;    /* file operations */
  201.     void *private_data;        /* private data for f_ops->open */
  202.     struct device *dev;        /* device for sysfs */
  203. };
  204.  
  205. /* return a device pointer linked to each sound device as a parent */
  206. static inline struct device *snd_card_get_device_link(struct snd_card *card)
  207. {
  208. #ifdef CONFIG_SYSFS_DEPRECATED
  209.     return card ? card->dev : NULL;
  210. #else
  211.     return card ? card->card_dev : NULL;
  212. #endif
  213. }
  214.  
  215. /* sound.c */
  216.  
  217. extern int snd_major;
  218. extern int snd_ecards_limit;
  219. extern struct class *sound_class;
  220.  
  221. void snd_request_card(int card);
  222.  
  223. int snd_register_device_for_dev(int type, struct snd_card *card,
  224.                 int dev,
  225.                 const struct file_operations *f_ops,
  226.                 void *private_data,
  227.                 const char *name,
  228.                 struct device *device);
  229.  
  230. /**
  231.  * snd_register_device - Register the ALSA device file for the card
  232.  * @type: the device type, SNDRV_DEVICE_TYPE_XXX
  233.  * @card: the card instance
  234.  * @dev: the device index
  235.  * @f_ops: the file operations
  236.  * @private_data: user pointer for f_ops->open()
  237.  * @name: the device file name
  238.  *
  239.  * Registers an ALSA device file for the given card.
  240.  * The operators have to be set in reg parameter.
  241.  *
  242.  * This function uses the card's device pointer to link to the
  243.  * correct &struct device.
  244.  *
  245.  * Returns zero if successful, or a negative error code on failure.
  246.  */
  247. static inline int snd_register_device(int type, struct snd_card *card, int dev,
  248.                       const struct file_operations *f_ops,
  249.                       void *private_data,
  250.                       const char *name)
  251. {
  252.     return snd_register_device_for_dev(type, card, dev, f_ops,
  253.                        private_data, name,
  254.                        snd_card_get_device_link(card));
  255. }
  256.  
  257. int snd_unregister_device(int type, struct snd_card *card, int dev);
  258. void *snd_lookup_minor_data(unsigned int minor, int type);
  259. int snd_add_device_sysfs_file(int type, struct snd_card *card, int dev,
  260.                   struct device_attribute *attr);
  261.  
  262. #ifdef CONFIG_SND_OSSEMUL
  263. int snd_register_oss_device(int type, struct snd_card *card, int dev,
  264.                 const struct file_operations *f_ops, void *private_data,
  265.                 const char *name);
  266. int snd_unregister_oss_device(int type, struct snd_card *card, int dev);
  267. void *snd_lookup_oss_minor_data(unsigned int minor, int type);
  268. #endif
  269.  
  270. int snd_minor_info_init(void);
  271. int snd_minor_info_done(void);
  272.  
  273. /* sound_oss.c */
  274.  
  275. #ifdef CONFIG_SND_OSSEMUL
  276. int snd_minor_info_oss_init(void);
  277. int snd_minor_info_oss_done(void);
  278. #else
  279. static inline int snd_minor_info_oss_init(void) { return 0; }
  280. static inline int snd_minor_info_oss_done(void) { return 0; }
  281. #endif
  282.  
  283. /* memory.c */
  284.  
  285. int copy_to_user_fromio(void __user *dst, const volatile void __iomem *src, size_t count);
  286. int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size_t count);
  287.  
  288. /* init.c */
  289.  
  290. extern struct snd_card *snd_cards[SNDRV_CARDS];
  291. int snd_card_locked(int card);
  292. #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
  293. #define SND_MIXER_OSS_NOTIFY_REGISTER    0
  294. #define SND_MIXER_OSS_NOTIFY_DISCONNECT    1
  295. #define SND_MIXER_OSS_NOTIFY_FREE    2
  296. extern int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int cmd);
  297. #endif
  298.  
  299. struct snd_card *snd_card_new(int idx, const char *id,
  300.              struct module *module, int extra_size);
  301. int snd_card_disconnect(struct snd_card *card);
  302. int snd_card_free(struct snd_card *card);
  303. int snd_card_free_when_closed(struct snd_card *card);
  304. int snd_card_register(struct snd_card *card);
  305. int snd_card_info_init(void);
  306. int snd_card_info_done(void);
  307. int snd_component_add(struct snd_card *card, const char *component);
  308. int snd_card_file_add(struct snd_card *card, struct file *file);
  309. int snd_card_file_remove(struct snd_card *card, struct file *file);
  310.  
  311. #ifndef snd_card_set_dev
  312. #define snd_card_set_dev(card, devptr) ((card)->dev = (devptr))
  313. #endif
  314.  
  315. /* device.c */
  316.  
  317. int snd_device_new(struct snd_card *card, snd_device_type_t type,
  318.            void *device_data, struct snd_device_ops *ops);
  319. int snd_device_register(struct snd_card *card, void *device_data);
  320. int snd_device_register_all(struct snd_card *card);
  321. int snd_device_disconnect(struct snd_card *card, void *device_data);
  322. int snd_device_disconnect_all(struct snd_card *card);
  323. int snd_device_free(struct snd_card *card, void *device_data);
  324. int snd_device_free_all(struct snd_card *card, snd_device_cmd_t cmd);
  325.  
  326. /* isadma.c */
  327.  
  328. #ifdef CONFIG_ISA_DMA_API
  329. #define DMA_MODE_NO_ENABLE    0x0100
  330.  
  331. void snd_dma_program(unsigned long dma, unsigned long addr, unsigned int size, unsigned short mode);
  332. void snd_dma_disable(unsigned long dma);
  333. unsigned int snd_dma_pointer(unsigned long dma, unsigned int size);
  334. #endif
  335.  
  336. /* misc.c */
  337. struct resource;
  338. void release_and_free_resource(struct resource *res);
  339.  
  340. #ifdef CONFIG_SND_VERBOSE_PRINTK
  341. void snd_verbose_printk(const char *file, int line, const char *format, ...)
  342.      __attribute__ ((format (printf, 3, 4)));
  343. #endif
  344. #if defined(CONFIG_SND_DEBUG) && defined(CONFIG_SND_VERBOSE_PRINTK)
  345. void snd_verbose_printd(const char *file, int line, const char *format, ...)
  346.      __attribute__ ((format (printf, 3, 4)));
  347. #endif
  348.  
  349. /* --- */
  350.  
  351. #ifdef CONFIG_SND_VERBOSE_PRINTK
  352. /**
  353.  * snd_printk - printk wrapper
  354.  * @fmt: format string
  355.  *
  356.  * Works like print() but prints the file and the line of the caller
  357.  * when configured with CONFIG_SND_VERBOSE_PRINTK.
  358.  */
  359. #define snd_printk(fmt, args...) \
  360.     snd_verbose_printk(__FILE__, __LINE__, fmt ,##args)
  361. #else
  362. #define snd_printk(fmt, args...) \
  363.     printk(fmt ,##args)
  364. #endif
  365.  
  366. #ifdef CONFIG_SND_DEBUG
  367.  
  368. #ifdef CONFIG_SND_VERBOSE_PRINTK
  369. /**
  370.  * snd_printd - debug printk
  371.  * @fmt: format string
  372.  *
  373.  * Works like snd_printk() for debugging purposes.
  374.  * Ignored when CONFIG_SND_DEBUG is not set.
  375.  */
  376. #define snd_printd(fmt, args...) \
  377.     snd_verbose_printd(__FILE__, __LINE__, fmt ,##args)
  378. #else
  379. #define snd_printd(fmt, args...) \
  380.     printk(fmt ,##args)
  381. #endif
  382.  
  383. #define snd_BUG()        WARN(1, "BUG?\n")
  384. #define snd_BUG_ON(cond)    WARN((cond), "BUG? (%s)\n", __stringify(cond))
  385.  
  386. #else /* !CONFIG_SND_DEBUG */
  387.  
  388. #define snd_printd(fmt, args...)    do { } while (0)
  389. #define snd_BUG()            do { } while (0)
  390. static inline int __snd_bug_on(void)
  391. {
  392.     return 0;
  393. }
  394. #define snd_BUG_ON(cond)        __snd_bug_on()  /* always false */
  395.  
  396. #endif /* CONFIG_SND_DEBUG */
  397.  
  398. #ifdef CONFIG_SND_DEBUG_VERBOSE
  399. /**
  400.  * snd_printdd - debug printk
  401.  * @format: format string
  402.  *
  403.  * Works like snd_printk() for debugging purposes.
  404.  * Ignored when CONFIG_SND_DEBUG_VERBOSE is not set.
  405.  */
  406. #define snd_printdd(format, args...) snd_printk(format, ##args)
  407. #else
  408. #define snd_printdd(format, args...) /* nothing */
  409. #endif
  410.  
  411.  
  412. #define SNDRV_OSS_VERSION         ((3<<16)|(8<<8)|(1<<4)|(0))    /* 3.8.1a */
  413.  
  414. /* for easier backward-porting */
  415. #if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE)
  416. #ifndef gameport_set_dev_parent
  417. #define gameport_set_dev_parent(gp,xdev) ((gp)->dev.parent = (xdev))
  418. #define gameport_set_port_data(gp,r) ((gp)->port_data = (r))
  419. #define gameport_get_port_data(gp) (gp)->port_data
  420. #endif
  421. #endif
  422.  
  423. /* PCI quirk list helper */
  424. struct snd_pci_quirk {
  425.     unsigned short subvendor;    /* PCI subvendor ID */
  426.     unsigned short subdevice;    /* PCI subdevice ID */
  427.     int value;            /* value */
  428. #ifdef CONFIG_SND_DEBUG_VERBOSE
  429.     const char *name;        /* name of the device (optional) */
  430. #endif
  431. };
  432.  
  433. #define _SND_PCI_QUIRK_ID(vend,dev) \
  434.     .subvendor = (vend), .subdevice = (dev)
  435. #define SND_PCI_QUIRK_ID(vend,dev) {_SND_PCI_QUIRK_ID(vend, dev)}
  436. #ifdef CONFIG_SND_DEBUG_VERBOSE
  437. #define SND_PCI_QUIRK(vend,dev,xname,val) \
  438.     {_SND_PCI_QUIRK_ID(vend, dev), .value = (val), .name = (xname)}
  439. #else
  440. #define SND_PCI_QUIRK(vend,dev,xname,val) \
  441.     {_SND_PCI_QUIRK_ID(vend, dev), .value = (val)}
  442. #endif
  443.  
  444. const struct snd_pci_quirk *
  445. snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list);
  446.  
  447.  
  448. #endif /* __SOUND_CORE_H */
  449.